/**
 * 沉浸式体验集成系统
 * 整合场景管理、WebXR和AI交互功能
 */
import { ImmersiveSceneManager } from './ImmersiveSceneManager.js';
import { UnifiedXRManager } from './core/UnifiedXRManager.js';
import { IMMERSIVE_SCENES, getSceneConfig, getPoetRecommendedScenes } from './config/immersive-scenes-config.js';
import { getPoetModelConfig } from './config/poet-models-config.js';
import { VoiceManager } from './VoiceManager.js';
import xrSubtitleSystem from './subtitles/XRSubtitleSystem.js';
import texturePlaneManager from './subtitles/TexturePlaneManager.js';
import { ProgressManager } from './ProgressManager.js';

export class ImmersiveExperience {
    constructor(renderer, scene, camera, options = {}) {
        this.renderer = renderer;
        this.scene = scene;
        this.camera = camera;
        
        // 核心组件
        this.sceneManager = null;
        this.webxr = options.unifiedXRManager || null; // 使用外部传入的UnifiedXRManager实例
        this.voiceManager = null;
        
        // 进度管理
        this.progressManager = options.progressManager || new ProgressManager();
        
        // 状态管理
        this.isInitialized = false;
        this.currentPoet = null;
        this.currentScene = null;
        this.currentCharacter = null;
        this.isXRActive = false;
        
        // 事件监听器
        this.eventListeners = new Map();
        
        // 性能监控
        this.performanceStats = {
            frameRate: 0,
            renderTime: 0,
            memoryUsage: 0
        };
    }

    /**
     * 初始化沉浸式体验系统
     */
    async init() {
        try {
            console.log('初始化沉浸式体验系统...');
            
            // 初始化场景管理器
            this.sceneManager = new ImmersiveSceneManager(
                this.renderer, 
                this.scene, 
                this.camera,
                { enableWebXR: false } // WebXR由UnifiedXRManager管理
            );
            await this.sceneManager.init();
            
            // 检查是否已有UnifiedXRManager实例
            if (!this.webxr) {
                // 如果没有外部提供的实例，尝试从window.app获取
                if (window.app && window.app.unifiedXRManager) {
                    this.webxr = window.app.unifiedXRManager;
                    console.log('✅ ImmersiveExperience使用window.app中的UnifiedXRManager实例');
                } else {
                    console.warn('⚠️ ImmersiveExperience未找到UnifiedXRManager实例');
                }
            } else {
                console.log('✅ ImmersiveExperience使用外部传入的UnifiedXRManager实例');
            }
            
            // 初始化语音管理器
            await this.initVoiceManager();
            
            // 初始化字幕系统
            this.initSubtitleSystem();
            
            // 设置事件监听
            this.setupEventListeners();
            
            // 设置性能监控
            this.setupPerformanceMonitoring();
            
            // 将实例绑定到window，供其他组件访问
            if (!window.app) {
                window.app = {};
            }
            window.app.immersiveExperience = this;
            
            this.isInitialized = true;
            console.log('沉浸式体验系统初始化完成');
            
            return true;
            
        } catch (error) {
            console.error('沉浸式体验系统初始化失败:', error);
            return false;
        }
    }
    
    /**
     * 初始化语音管理器
     */
    async initVoiceManager() {
        try {
            console.log('初始化语音管理器...');
            
            // 优先使用window.app中的语音管理器实例，避免重复初始化
            if (window.app && window.app.voiceManager) {
                this.voiceManager = window.app.voiceManager;
                console.log('✅ 复用现有语音管理器实例');
            } else {
                // 如果没有现有实例，创建新实例
                console.warn('⚠️ 未找到现有语音管理器实例，创建新实例');
                this.voiceManager = new VoiceManager({
                    useWebXR: true,  // 启用WebXR模式
                    enableDebug: true
                });
                
                // 初始化语音管理器
                await this.voiceManager.init();
                
                // 将语音管理器绑定到window对象，供其他组件访问
                if (!window.app) {
                    window.app = {};
                }
                window.app.voiceManager = this.voiceManager;
            }
            
            console.log('语音管理器初始化完成');
            return true;
        } catch (error) {
            console.error('语音管理器初始化失败:', error);
            return false;
        }
    }

    /**
     * 设置事件监听器
     */
    setupEventListeners() {
        // 全局事件监听
        window.addEventListener('resize', this.onWindowResize.bind(this));
        window.addEventListener('beforeunload', this.onBeforeUnload.bind(this));
        
        // WebXR事件
        window.addEventListener('webxr:xrstart', (event) => {
            this.isXRActive = true;
            this.onXRStart(event.detail);
        });
        
        window.addEventListener('webxr:xrend', (event) => {
            this.isXRActive = false;
            this.onXREnd(event.detail);
        });
        
        window.addEventListener('webxr:sceneloaded', (event) => {
            this.onSceneLoaded(event.detail);
        });
        
        window.addEventListener('webxr:characterloaded', (event) => {
            this.onCharacterLoaded(event.detail);
        });
        
        window.addEventListener('webxr:characterinteraction', (event) => {
            this.onCharacterInteraction(event.detail);
        });
        
        // 语音事件监听
        if (this.voiceManager) {
            // 监听语音识别结果
            this.voiceManager.addEventListener('recognitionResult', (event) => {
                this.handleVoiceInput(event.detail.text);
            });
            
            // 使用改进的语音事件监听方法
            this.setupVoiceEventListeners();
        }
    }
    
    /**
     * 窗口大小变化处理
     */
    onWindowResize() {
        if (this.camera) {
            this.camera.aspect = window.innerWidth / window.innerHeight;
            this.camera.updateProjectionMatrix();
        }
        
        if (this.renderer) {
            this.renderer.setSize(window.innerWidth, window.innerHeight);
        }
    }
    
    /**
     * 页面卸载前处理
     */
    onBeforeUnload() {
        this.dispose();
    }
    
    /**
     * XR会话错误处理
     */
    onXRSessionError(detail) {
        console.error('XR会话错误:', detail);
        this.dispatchEvent('xrsessionerror', detail);
    }
    
    /**
     * 处理语音输入
     * @param {string} text - 识别到的文本
     */
    handleVoiceInput(text) {
        console.log('收到语音输入:', text);
        
        // 如果在XR模式下，将语音输入传递给当前角色
        if (this.isXRActive && this.currentCharacter) {
            this.sendQueryToCharacter(this.currentCharacter, text);
        } else if (this.currentPoet) {
            this.sendQueryToCharacter(this.currentPoet, text);
        }
        
        // 触发语音输入事件
        this.dispatchEvent('voiceinput', { text });
    }
    
    /**
     * 改进语音事件处理
     */
    setupVoiceEventListeners() {
        // 移除可能重复的监听器
        this.voiceManager.removeEventListener('speechStart', this._onSpeechStart);
        this.voiceManager.removeEventListener('speechEnd', this._onSpeechEnd);
        
        // 绑定新的监听器
        this._onSpeechStart = (event) => {
            this.handleSpeechStart(event);
        };
        
        this._onSpeechEnd = (event) => {
            this.handleSpeechEnd(event);
        };
        
        this.voiceManager.addEventListener('speechStart', this._onSpeechStart);
        this.voiceManager.addEventListener('speechEnd', this._onSpeechEnd);
    }
    
    /**
     * 处理语音合成开始
     * @param {Object} detail - 语音合成详情
     */
    handleSpeechStart(detail) {
        console.log('🎤 语音开始事件:', detail);
        
        // 强制更新XR字幕 - 这是核心功能，必须执行
        try {
            this.forceUpdateXRSubtitle(detail.text, detail.duration);
            console.log('✅ XR字幕已更新');
        } catch (subtitleError) {
            console.error('❌ 更新XR字幕失败:', subtitleError);
            // 即使字幕更新失败，也要继续执行其他逻辑
        }
        
        // 使用备用方案设置说话状态
        if (this.currentCharacter) {
            try {
                this.setCharacterSpeakingState(this.currentCharacter, true);
                console.log('✅ 角色说话状态已设置为true');
            } catch (speakingError) {
                console.error('❌ 设置角色说话状态为true失败:', speakingError);
                // 即使设置说话状态失败，也要继续执行事件分发
            }
        }
        
        // 分发事件，确保事件链不会中断
        try {
            this.dispatchEvent('speechstart', detail);
            console.log('✅ speechstart事件已分发');
        } catch (dispatchError) {
            console.error('❌ 分发speechstart事件失败:', dispatchError);
        }
    }
  
  /**
   * 强制更新XR字幕
   * @param {string} text - 字幕文本
   * @param {number} duration - 持续时间（秒）
   * @param {boolean} syncWithAudio - 是否与音频同步逐句显示
   */
  forceUpdateXRSubtitle(text, duration = 5, syncWithAudio = true) {
    // 增强的XR模式检查：只有在XR模式下才显示XR字幕
    if (!this.isXRActive && !this.isXRModeActive()) {
      console.log('📱 非XR模式，跳过XR字幕显示');
      return;
    }
    
    console.log('🎯 强制更新XR字幕:', text, '持续时间:', duration, '是否同步:', syncWithAudio);
    
    // 方法1: 使用subtitleSystem - 修正属性名检查
    if (this.subtitleSystem) {
      // 同时检查initialized和isInitialized两种可能的属性名
      const isSystemInitialized = this.subtitleSystem.initialized || this.subtitleSystem.isInitialized;
      
      if (isSystemInitialized) {
        // 优先使用updateContent方法并启用同步模式
        if (this.subtitleSystem.updateContent && syncWithAudio) {
          // 与音频同步逐句显示
          this.subtitleSystem.updateContent(text, duration, true);
          return;
        }
        // 优先使用showSubtitle方法
        if (this.subtitleSystem.showSubtitle) {
          this.subtitleSystem.showSubtitle(text, duration);
          return;
        }
        // 如果showSubtitle不存在，尝试使用showText方法
        if (this.subtitleSystem.showText) {
          this.subtitleSystem.showText(text);
          
          // 设置自动隐藏
          setTimeout(() => {
            if (this.subtitleSystem && this.subtitleSystem.showText) {
              this.subtitleSystem.showText("");
            }
          }, duration * 1000);
          return;
        }
      }
    }
    
    // 方法2: 直接使用texturePlaneManager
    if (this.texturePlaneManager) {
      if (this.texturePlaneManager.updateSubtitle) {
        this.texturePlaneManager.updateSubtitle(text);
      }
      
      // 确保平面可见
      if (this.texturePlaneManager.plane) {
        this.texturePlaneManager.plane.visible = true;
      }
      
      // 自动隐藏
      setTimeout(() => {
        if (this.texturePlaneManager) {
          if (this.texturePlaneManager.updateSubtitle) {
            this.texturePlaneManager.updateSubtitle("");
          }
          if (this.texturePlaneManager.plane) {
            this.texturePlaneManager.plane.visible = false;
          }
        }
      }, duration * 1000);
      
      return;
    }
    
    // 方法3: 紧急初始化
    console.warn('⚠️ XR字幕系统不可用，尝试紧急初始化...');
    this.initializeSubtitleSystem();
    
    setTimeout(() => {
      this.forceUpdateXRSubtitle(text, duration);
    }, 500);
  }
    
    /**
     * 新增双重字幕更新方法
     * @param {string} text - 字幕文本
     * @param {number} duration - 持续时间
     */
    updateBothSubtitles(text, duration) {
        const audioDuration = duration || this.calculateAudioDuration(text);
        
        console.log('🔄 开始双重字幕更新:', text);
        
        // 1. 更新2D UI字幕
        if (this.uiManager && this.uiManager.showIntervalBasedSubtitles) {
            this.uiManager.showIntervalBasedSubtitles(text, audioDuration);
            console.log('✅ 2D UI字幕已更新');
        }
        
        // 2. 更新XR字幕 - 关键修复！
        this.updateXRSubtitle(text, audioDuration);
        
        console.log('🎯 双重字幕更新完成');
    }
    
    /**
     * 新增XR字幕更新方法
     * @param {string} text - 字幕文本
     * @param {number} duration - 持续时间
     */
    updateXRSubtitle(text, duration = 5) {
        if (!this.isXRModeActive()) {
            console.log('📱 非XR模式，跳过XR字幕更新');
            return;
        }
        
        console.log('🎮 开始更新XR字幕:', text);
        
        // 方法1: 通过现有的subtitleSystem
        if (this.subtitleSystem && this.subtitleSystem.showSubtitle) {
            this.subtitleSystem.showSubtitle(text, duration);
            console.log('✅ 通过subtitleSystem更新XR字幕');
            return;
        }
        
        // 方法2: 直接通过texturePlaneManager
        if (this.texturePlaneManager && this.texturePlaneManager.updateSubtitle) {
            this.texturePlaneManager.updateSubtitle(text);
            
            // 设置自动清除
            setTimeout(() => {
                if (this.texturePlaneManager) {
                    this.texturePlaneManager.updateSubtitle("");
                }
            }, duration * 1000);
            
            console.log('✅ 直接通过TexturePlaneManager更新XR字幕');
            return;
        }
        
        // 方法3: 使用xrSubtitleSystem（主要方法）
        if (window.app && window.app.xrSubtitleSystem) {
            window.app.xrSubtitleSystem.showText(text);
            console.log('✅ 通过window.app.xrSubtitleSystem更新XR字幕');
            return;
        }
        
        // 方法4: 紧急初始化
        console.warn('⚠️ XR字幕系统未就绪，尝试紧急初始化...');
        this.initSubtitleSystem();
        
        setTimeout(() => {
            this.updateXRSubtitle(text, duration);
        }, 500);
    }
    
    /**
     * 计算音频时长
     * @param {string} text - 文本内容
     * @returns {number} 预计持续时间（秒）
     */
    calculateAudioDuration(text) {
        const chineseChars = text.replace(/[^\u4e00-\u9fa5]/g, '').length;
        const duration = chineseChars * 0.3 + 2; // 每个汉字0.3秒 + 基础2秒
        return Math.min(duration, 10);
    }
    
    /**
     * 检测XR模式
     * @returns {boolean} XR模式是否激活
     */
    isXRModeActive() {
        // 优先使用自身的isXRActive状态
        if (this.isXRActive) {
            return true;
        }
        
        // 备选：检查XR管理器
        return this.webxr && 
               this.webxr.isInXRSession && 
               this.webxr.isInXRSession();
    }
    
    /**
     * 处理语音合成结束
     * @param {Object} detail - 语音合成详情
     */
    handleSpeechEnd(detail) {
        console.log('🔚 语音结束事件:', detail);
        
        // 使用备用方案设置说话状态
        if (this.currentCharacter) {
            try {
                this.setCharacterSpeakingState(this.currentCharacter, false);
                console.log('✅ 角色说话状态已设置为false');
            } catch (speakingError) {
                console.error('❌ 设置角色说话状态为false失败:', speakingError);
                // 即使设置说话状态失败，也要继续执行语音识别重启逻辑
            }
        }
        
        // 确保语音识别重启 - 这是关键的连续对话功能，必须执行
        try {
            this.ensureVoiceRecognitionRestart();
            console.log('✅ 语音识别重启流程已启动');
        } catch (restartError) {
            console.error('❌ 语音识别重启失败:', restartError);
            // 即使主重启方法失败，也要尝试直接重启
            if (this.voiceManager && this.voiceManager.startListening) {
                console.log('🔄 尝试直接重启语音识别');
                setTimeout(() => {
                    try {
                        this.voiceManager.startListening();
                    } catch (directError) {
                        console.error('❌ 直接重启语音识别也失败:', directError);
                    }
                }, 500);
            }
        }
        
        // 分发事件，确保事件链不会中断
        try {
            this.dispatchEvent('speechend', detail);
            console.log('✅ speechend事件已分发');
        } catch (dispatchError) {
            console.error('❌ 分发speechend事件失败:', dispatchError);
        }
    }
    
    /**
     * 备用方案设置角色说话状态
     * @param {Object} character - 角色对象
     * @param {boolean} speaking - 是否正在说话
     */
    setCharacterSpeakingState(character, speaking) {
        console.log(`🎭 设置角色 ${character.id || 'unknown'} 说话状态: ${speaking}`);
        
        // 方案1: 通过场景管理器
        if (this.sceneManager && typeof this.sceneManager.setCharacterSpeaking === 'function') {
            this.sceneManager.setCharacterSpeaking(character, speaking);
            return;
        }
        
        // 方案2: 直接调用3D角色对象的startSpeaking/stopSpeaking方法
        if (character && typeof character.startSpeaking === 'function' && typeof character.stopSpeaking === 'function') {
            if (speaking) {
                character.startSpeaking();
            } else {
                character.stopSpeaking();
            }
            console.log('✅ 直接调用角色的startSpeaking/stopSpeaking方法');
            return;
        }
        
        // 方案3: 通过poetCharacter实例
        if (this.poetCharacter) {
            if (typeof this.poetCharacter.startSpeaking === 'function' && typeof this.poetCharacter.stopSpeaking === 'function') {
                if (speaking) {
                    this.poetCharacter.startSpeaking();
                } else {
                    this.poetCharacter.stopSpeaking();
                }
                console.log('✅ 通过poetCharacter实例设置说话状态');
                return;
            }
        }
        
        // 方案4: 使用现有的updateCharacterSpeakingState方法
        if (character && character.setSpeakingState) {
            character.setSpeakingState(speaking);
            return;
        }
        
        // 方案5: 直接控制动画
        console.warn('⚠️ 使用直接动画控制');
        if (character && character.animation && character.animation.setAnimation) {
            character.animation.setAnimation(speaking ? 'speaking' : 'idle');
        }
    }
    
    /**
     * 确保语音识别重启
     */
    ensureVoiceRecognitionRestart() {
        if (!this.voiceManager) return;
        
        console.log('🔄 执行语音识别重启流程');
        
        try {
            // 优先使用VoiceManager的ensureRecognitionRestart方法
            if (typeof this.voiceManager.ensureRecognitionRestart === 'function') {
                console.log('📋 使用VoiceManager.ensureRecognitionRestart方法');
                this.voiceManager.ensureRecognitionRestart();
                return;
            }
        } catch (error) {
            console.error('❌ 重启语音识别失败:', error);
        }
        
        // 降级使用传统的重启方式
        console.log('📋 降级使用传统重启方式');
        this._fallbackRecognitionRestart();
    }
    
    /**
     * 降级的语音识别重启方案
     * 当ensureRecognitionRestart方法不可用时使用
     */
    _fallbackRecognitionRestart() {
        // 检查是否需要重启
        if (!this.voiceManager.isListening && !this.voiceManager._isStarting) {
            console.log('🔄 语音结束后确保重启识别');
            setTimeout(() => {
                this.voiceManager.startListening().catch(error => {
                    console.error('❌ 语音重启失败:', error);
                    // 失败后再次尝试
                    setTimeout(() => {
                        this.voiceManager.startListening().catch(console.error);
                    }, 1000);
                });
            }, 800); // 增加到800ms延迟
        }
    }
    
    /**
     * 向角色发送查询
     * @param {Object} character - 角色对象
     * @param {string} query - 查询文本
     */
    async sendQueryToCharacter(character, query) {
        try {
            console.log(`向角色发送查询: ${query}`);
            
            // 这里应该调用AI服务获取响应
            // 模拟AI响应
            const response = await this.getAIResponse(character.id, query);
            
            // 播放AI响应
            if (this.voiceManager) {
                await this.voiceManager.speak(response, {
                    voice: this.getCharacterVoice(character),
                    rate: 0.9,
                    pitch: 1.0
                });
            }
            
            return response;
        } catch (error) {
            console.error('发送查询到角色失败:', error);
            throw error;
        }
    }
    
    /**
     * 获取AI响应
     * @param {string} characterId - 角色ID
     * @param {string} query - 查询文本
     */
    async getAIResponse(characterId, query) {
        // 实际项目中应调用API获取AI响应
        // 这里使用模拟响应
        return `这是来自角色 ${characterId} 的回复，感谢您的提问: "${query}"`;
    }
    
    /**
     * 获取角色语音配置
     * @param {Object} character - 角色对象
     */
    getCharacterVoice(character) {
        // 根据角色类型或ID返回不同的语音配置
        const voiceMap = {
            'libai': 'zh-CN-YunxiNeural',
            'dufu': 'zh-CN-YunzeNeural',
            'liubei': 'zh-CN-YunjianNeural',
            'sunquan': 'zh-CN-YunxiNeural',
            'default': 'zh-CN-YunxiNeural'
        };
        
        return voiceMap[character.id] || voiceMap.default;
    }
    
    /**
     * 更新角色说话状态
     * @param {Object} character - 角色对象
     * @param {boolean} isSpeaking - 是否正在说话
     */
    updateCharacterSpeakingState(character, isSpeaking) {
        try {
            console.log(`🎭 更新角色 ${character?.id || 'unknown'} 说话状态: ${isSpeaking}`);
            if (character && character.setSpeakingState) {
                character.setSpeakingState(isSpeaking);
                console.log('✅ 使用角色的setSpeakingState方法更新状态');
            } else {
                console.warn('⚠️ 无法更新角色说话状态，角色或setSpeakingState方法不存在');
            }
        } catch (error) {
            // 关键修复：捕获错误但不中断处理流程
            console.error('❌ 更新角色说话状态时出错:', error);
            // 即使出错也继续执行
        }
    }

    /**
     * 设置性能监控
     */
    setupPerformanceMonitoring() {
        this.lastTime = performance.now();
        this.frameCount = 0;
    }

    updatePerformanceStats() {
        const currentTime = performance.now();
        const deltaTime = currentTime - this.lastTime;
        this.frameCount++;
        
        if (deltaTime >= 1000) { // 每秒更新一次
            this.performanceStats.frameRate = Math.round((this.frameCount * 1000) / deltaTime);
            this.performanceStats.renderTime = deltaTime / this.frameCount;
            
            // 获取内存使用情况（如果支持）
            if (performance.memory) {
                this.performanceStats.memoryUsage = Math.round(
                    performance.memory.usedJSHeapSize / 1024 / 1024
                );
            }
            
            this.frameCount = 0;
            this.lastTime = currentTime;
            
            // 触发性能更新事件
            this.dispatchEvent('performanceupdate', this.performanceStats);
        }
        
        // 更新字幕系统
        xrSubtitleSystem.update();
    }

    /**
     * 加载诗人场景
     * @param {string} poetId - 诗人ID
     * @param {string} sceneId - 场景ID（可选）
     */
    async loadPoetScene(poetId, sceneId = null) {
        try {
            // 开始加载进度
            this.progressManager.startLoading('正在加载诗人场景...');
            
            console.log(`加载诗人场景: ${poetId}`);
            
            // 获取推荐场景
            const recommendedScenes = getPoetRecommendedScenes(poetId);
            const targetSceneId = sceneId || recommendedScenes[0] || 'abandonedFactory';
            
            // 更新进度：场景配置加载完成
            this.progressManager.updateProgress(20, '正在加载场景配置...');
            
            // 加载场景
            const success = await this.sceneManager.loadScene(targetSceneId);
            
            if (success) {
                this.currentPoet = poetId;
                this.currentScene = targetSceneId;
                
                // 更新进度：场景加载完成，开始加载角色
                this.progressManager.updateProgress(60, '场景加载完成，正在加载诗人角色...');
                
                // 加载诗人角色模型
                await this.loadPoetCharacter(poetId);
                
                // 更新进度：角色加载完成
                this.progressManager.updateProgress(90, '角色加载完成，正在初始化交互系统...');
                
                console.log(`诗人场景加载完成: ${poetId} in ${targetSceneId}`);
                this.dispatchEvent('poetsceneloaded', { poetId, sceneId: targetSceneId });
                
                // 完成加载
                this.progressManager.completeLoading();
                
                return true;
            } else {
                throw new Error('场景加载失败');
            }
            
        } catch (error) {
            console.error('加载诗人场景失败:', error);
            // 加载失败
            this.progressManager.failLoading('场景加载失败');
            return false;
        }
    }

    /**
     * 加载诗人角色
     * @param {string} poetId - 诗人ID
     */
    async loadPoetCharacter(poetId) {
        try {
            // 更新进度：开始加载角色模型
            this.progressManager.updateProgress(70, '正在加载角色模型...');
            
            // 构建角色模型URL（约定：/static/models/characters/<poetId>.glb）
const characterUrl = `/static/models/characters/${poetId}.glb`;

            // 应用诗人模型配置中的缩放
            const modelConfig = getPoetModelConfig(poetId);

            // 使用场景管理器在当前场景中加载角色
            const modelData = await this.sceneManager.loadCharacter(
                poetId,
                characterUrl,
                {
                    scale: (modelConfig && typeof modelConfig.scale === 'number') ? modelConfig.scale : 1.0,
                    enableAnimations: true
                }
            );

            if (modelData) {
                // 更新进度：角色模型加载完成，开始配置交互
                this.progressManager.updateProgress(85, '角色模型加载完成，正在配置交互系统...');
                
                this.currentCharacter = poetId;
                // 为当前角色配置语音交互
                this.setupCharacterVoiceInteraction(poetId);
                // 设置AI角色
                await this.setupAICharacter(poetId);
                
                // 更新进度：角色配置完成
                this.progressManager.updateProgress(95, '角色配置完成');
                
                console.log(`诗人角色加载完成: ${poetId}`);
                return true;
            } else {
                console.warn(`诗人角色加载失败，使用默认占位符: ${poetId}`);
                return false;
            }
        } catch (error) {
            console.error('加载诗人角色失败:', error);
            return false;
        }
    }

    /**
     * 设置AI角色
     * @param {string} poetId - 诗人ID
     */
    async setupAICharacter(poetId) {
        this.currentPoet = poetId;
        console.log(`AI角色设置完成: ${poetId}`);
    }

    /**
     * 与诗人对话
     * @param {string} message - 用户消息
     * @returns {Promise<Object>} AI响应
     */
    async chatWithPoet(message) {
        if (!this.currentCharacter) {
            throw new Error('角色未初始化');
        }
        
        try {
            console.log(`与${this.currentCharacter}对话:`, message);
            
            // 使用现有的后端API
            const response = await fetch('/api/chat', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                },
                body: JSON.stringify({
                    message: message,
                    user_id: 'immersive_user',
                    session_id: `session_${Date.now()}`
                })
            });
            
            if (!response.ok) {
                throw new Error(`API请求失败: ${response.status}`);
            }
            
            const data = await response.json();
            
            // 处理AI响应
            await this.onAIResponse(data.reply);
            
            // 处理动画
            if (data.animation) {
                await this.onAIAction(data.animation);
            }
            
            return data;
            
        } catch (error) {
            console.error('对话失败:', error);
            throw error;
        }
    }

    /**
     * 处理AI响应
     * @param {string} text - AI响应文本
     */
    async onAIResponse(text) {
        console.log('AI响应:', text);
        
        // 触发响应事件
        this.dispatchEvent('airesponse', { text, character: this.currentCharacter });
        
        // 语音合成将通过后端API处理，这里只处理文本显示
        console.log('AI回复文本已处理:', text);
    }

    /**
     * 处理AI动作
     * @param {Object} action - AI动作
     */
    async onAIAction(action) {
        console.log('AI动作:', action);
        
        // 执行角色动作
        if (this.currentCharacter && action.type) {
            await this.webxr.interactWithCharacter(
                this.currentCharacter, 
                action.type, 
                action.params || {}
            );
        }
        
        // 触发动作事件
        this.dispatchEvent('aiaction', { action, character: this.currentCharacter });
    }

    /**
     * 切换场景
     * @param {string} sceneId - 场景ID
     */
    async switchScene(sceneId) {
        try {
            // 开始加载进度
            this.progressManager.startLoading('正在切换场景...');
            
            // 更新进度：开始加载新场景
            this.progressManager.updateProgress(20, '正在加载新场景...');
            
            const success = await this.webxr.loadImmersiveScene(sceneId);
            
            if (success) {
                this.currentScene = sceneId;
                
                // 更新进度：场景加载完成，开始重新加载角色
                this.progressManager.updateProgress(60, '场景加载完成，正在重新加载角色...');
                
                // 重新加载当前角色
                if (this.currentCharacter) {
                    await this.loadPoetCharacter(this.currentCharacter);
                }
                
                // 更新进度：角色重新加载完成
                this.progressManager.updateProgress(90, '角色重新加载完成，正在初始化交互系统...');
                
                console.log(`场景切换完成: ${sceneId}`);
                this.dispatchEvent('sceneswitched', { sceneId });
                
                // 完成加载
                this.progressManager.completeLoading();
                
                return true;
            } else {
                throw new Error('场景切换失败');
            }
            
        } catch (error) {
            console.error('切换场景失败:', error);
            // 加载失败
            this.progressManager.failLoading('场景切换失败');
            return false;
        }
    }

    /**
     * 进入XR模式
     * @param {string} mode - XR模式 ('vr' 或 'ar')
     */
    async enterXR(mode = 'vr') {
        try {
            // 这里需要根据实际的WebXR API实现
            console.log(`进入${mode.toUpperCase()}模式`);
            
            // 触发XR进入事件
            this.dispatchEvent('xrenter', { mode });
            
            return true;
            
        } catch (error) {
            console.error('进入XR模式失败:', error);
            return false;
        }
    }

    /**
     * 退出XR模式
     */
    async exitXR() {
        try {
            console.log('退出XR模式');
            
            // 触发XR退出事件
            this.dispatchEvent('xrexit');
            
            return true;
            
        } catch (error) {
            console.error('退出XR模式失败:', error);
            return false;
        }
    }

    /**
     * 获取可用场景列表
     */
    getAvailableScenes() {
        return Object.keys(IMMERSIVE_SCENES).map(sceneId => ({
            id: sceneId,
            ...getSceneConfig(sceneId)
        }));
    }

    /**
     * 获取当前状态
     */
    getCurrentState() {
        return {
            isInitialized: this.isInitialized,
            currentPoet: this.currentPoet,
            currentScene: this.currentScene,
            currentCharacter: this.currentCharacter,
            isXRActive: this.isXRActive,
            performance: this.performanceStats,
            webxrState: this.webxr?.getXRState(),
            aiStatus: this.aiAPI?.getStatus()
        };
    }

    /**
     * 事件处理器
     */
    /**
     * XR会话开始时的处理
     */
    onXRStart(detail) {
        console.log('XR会话开始:', detail);
        this.dispatchEvent('xrstart', detail);
        
        // 确保字幕系统已初始化
        if (!window.app.xrSubtitleSystem || !window.app.xrSubtitleSystem.isInitialized) {
            this.initSubtitleSystem();
        }
        
        // 通知场景管理器XR模式已激活
        if (this.sceneManager) {
            this.sceneManager.onXRModeChange(true);
        }
        
        // 激活语音系统
        if (this.voiceManager) {
            this.voiceManager.activateWebXRMode();
        }
        
        // 如果WebXR管理器支持，启动语音输入
        if (this.webxr && typeof this.webxr.triggerVoiceInputStart === 'function') {
            this.webxr.triggerVoiceInputStart();
        }
        
        // 确保语音系统在XR模式下正常工作
        this.ensureVoiceSystemActive();
        
        // 设置XR模式下的字幕位置
        this.positionSubtitlesForXR();
        
        // 重新配置字幕系统以适应XR模式
        if (this.sceneManager && this.sceneManager.xrCamera) {
            xrSubtitleSystem.reconfigure({
                camera: this.sceneManager.xrCamera
            });
        }
    }
    
    /**
     * 为XR模式优化字幕位置和渲染
     */
    positionSubtitlesForXR() {
        console.log('设置XR模式下的字幕位置');
        
        // 设置字幕位置偏移
        xrSubtitleSystem.setPositionOffset(0, -0.3, -0.8); // 调整到视野下方
        
        // 可以添加其他XR特定的配置
        console.log('✅ XR字幕位置已调整');
    }
    
    /**
     * 确保语音系统在XR模式下处于活动状态
     */
    async ensureVoiceSystemActive() {
        try {
            console.log('确保XR模式下语音系统处于活动状态...');
            
            // 确保语音管理器已初始化并启动
            if (this.voiceManager && !this.voiceManager.isInitialized) {
                await this.voiceManager.init();
            }
            
            // 确保音频上下文处于活动状态
            if (this.voiceManager && typeof this.voiceManager.ensureAudioActive === 'function') {
                await this.voiceManager.ensureAudioActive();
            }
            
            console.log('语音系统活动状态检查完成');
        } catch (error) {
            console.error('确保语音系统活动状态失败:', error);
        }
    }
    
    /**
     * 处理语音输入
     */
    handleVoiceInput(text) {
        console.log('收到语音输入:', text);
        
        // 这里可以将语音输入传递给AI角色进行处理
        // 目前假设存在AICharacter类可以处理输入
        if (this.currentCharacter && window.aiCharacter) {
            window.aiCharacter.handleUserInput(text);
        } else {
            console.warn('没有活动的AI角色处理语音输入');
        }
        
        // 显示用户语音输入字幕
        xrSubtitleSystem.showText(text);
    }
    
    // handleSpeechStart和handleSpeechEnd方法已在文件前面定义，删除重复实现
    
    /**
     * 为角色配置语音交互
     */
    setupCharacterVoiceInteraction(poetId) {
        console.log(`为角色${poetId}配置语音交互`);
        
        // 这里可以根据诗人ID配置特定的语音参数
        // 例如，可以设置不同诗人的语音类型、语速等
        if (this.voiceManager && typeof this.voiceManager.setVoiceForCharacter === 'function') {
            try {
                this.voiceManager.setVoiceForCharacter(poetId);
            } catch (error) {
                console.error(`为角色${poetId}设置语音失败:`, error);
            }
        }
    }
    
    /**
   * 初始化字幕系统
   */
  initSubtitleSystem() {
    this.initializeSubtitleSystem();
  }
  
  /**
   * 修改字幕系统初始化方法
   * @returns {boolean} 初始化是否成功
   */
  initializeSubtitleSystem() {
    try {
      console.log('🎬 开始初始化字幕系统...');
      
      // 优先使用当前类的scene和camera（构造函数传入的）
      let targetScene = this.scene;
      let targetCamera = this.camera;
      
      // 如果sceneManager可用，使用其场景和相机
      if (this.sceneManager && this.sceneManager.scene && this.sceneManager.camera) {
        targetScene = this.sceneManager.scene;
        targetCamera = this.sceneManager.camera;
      }
      
      // 尝试获取音频管理器
      let audioManager = null;
      if (window.app && window.app.audioManager) {
        audioManager = window.app.audioManager;
        console.log('🎵 找到window.app中的音频管理器');
      } else if (this.audioManager) {
        audioManager = this.audioManager;
        console.log('🎵 使用当前实例中的音频管理器');
      }
      
      // 初始化 XRSubtitleSystem - 使用更安全的初始化方式
      const initSuccess = xrSubtitleSystem.initialize({
        immersiveExperience: this,
        voiceManager: this.voiceManager,
        scene: targetScene,
        camera: targetCamera,
        audioManager: audioManager
      });
      
      // 保存引用
      this.subtitleSystem = xrSubtitleSystem;
      
      // 获取texturePlaneManager引用
      this.texturePlaneManager = texturePlaneManager;
      
      // 尝试初始化，如果失败则使用备用方案
      if (!initSuccess) {
        console.warn('⚠️ XRSubtitleSystem 初始化失败，使用备用字幕方案');
        this.setupFallbackSubtitleSystem();
      }
      
      // 绑定到全局对象以便调试
      if (!window.app) {
        window.app = {};
      }
      window.app.subtitleSystem = this.subtitleSystem;
      window.app.xrSubtitleSystem = xrSubtitleSystem;
      window.app.texturePlaneManager = this.texturePlaneManager;
      
      console.log('✅ 字幕系统初始化完成');
      return true;
      
    } catch (error) {
      console.error('❌ 字幕系统初始化失败:', error);
      this.setupFallbackSubtitleSystem();
      return false;
    }
  }
  
  /**
   * 新增备用字幕系统
   */
  setupFallbackSubtitleSystem() {
    console.log('🔄 设置备用字幕系统...');
    
    this.subtitleSystem = {
      showSubtitle: (text, duration = 5) => {
        console.log('🎯 备用字幕系统显示:', text);
        if (this.texturePlaneManager) {
          this.texturePlaneManager.updateSubtitle(text);
          
          // 设置自动清除
          setTimeout(() => {
            if (this.texturePlaneManager) {
              this.texturePlaneManager.updateSubtitle("");
            }
          }, duration * 1000);
        }
      },
      hideSubtitle: () => {
        if (this.texturePlaneManager) {
          this.texturePlaneManager.updateSubtitle("");
        }
      },
      initialized: true
    };
  }

    onXREnd(detail) {
        console.log('XR会话结束:', detail);
        
        // 更新状态
        this.isXRActive = false;
        
        // 移除立即停用WebXR语音模式的调用，避免语音识别系统被错误停止
        // 保留语音系统处于准备状态，以便在需要时可以快速启动
        
        // 如果WebXR管理器支持，调用其会话结束处理方法，但不要直接停止语音输入
        if (this.webxr && typeof this.webxr.onXRSessionEnd === 'function') {
            this.webxr.onXRSessionEnd();
        }
        
        // 触发自定义事件，保留事件监听器功能
        this.dispatchEvent('xrend', detail);
    }

    onSceneLoaded(detail) {
        console.log('场景加载完成:', detail);
        this.dispatchEvent('sceneloaded', detail);
    }

    onCharacterLoaded(detail) {
        console.log('角色加载完成:', detail);
        this.dispatchEvent('characterloaded', detail);
    }

    onCharacterInteraction(detail) {
        console.log('角色交互:', detail);
        this.dispatchEvent('characterinteraction', detail);
    }

    /**
     * 事件分发
     */
    dispatchEvent(type, data = {}) {
        const event = new CustomEvent(`immersive:${type}`, { detail: data });
        window.dispatchEvent(event);
        
        // 内部事件监听器
        if (this.eventListeners.has(type)) {
            this.eventListeners.get(type).forEach(callback => {
                try {
                    callback(data);
                } catch (error) {
                    console.error(`事件监听器错误 (${type}):`, error);
                }
            });
        }
    }

    /**
     * 添加事件监听器
     */
    addEventListener(type, callback) {
        if (!this.eventListeners.has(type)) {
            this.eventListeners.set(type, []);
        }
        this.eventListeners.get(type).push(callback);
    }

    /**
     * 移除事件监听器
     */
    removeEventListener(type, callback) {
        if (this.eventListeners.has(type)) {
            const listeners = this.eventListeners.get(type);
            const index = listeners.indexOf(callback);
            if (index > -1) {
                listeners.splice(index, 1);
            }
        }
    }

    /**
     * 清理资源
     */
    dispose() {
        // 清理事件监听器
        this.eventListeners.clear();
        
        // 清理组件
        if (this.sceneManager) {
            this.sceneManager.dispose();
        }
        
        if (this.webxr) {
            this.webxr.cleanup();
        }
        
        if (this.aiAPI) {
            this.aiAPI.clearHistory();
        }
        
        // 清理字幕系统
        xrSubtitleSystem.dispose();
        
        console.log('沉浸式体验系统已清理');
    }
}

// 创建全局实例